1. Technical Field
This invention generally relates to computer systems, and more specifically relates to data processing in computer systems using a graphical user interface (GUI).
2. Background Art
The development of the EDVAC computer system of 1948 is often cited as the beginning of the computer era. Since that time, computer systems have evolved into extremely sophisticated devices, and computer systems may be found in many different settings. In the early days of computers, one or more relatively powerful and expensive computers could be shared by many users. A network of computer terminals were typically connected to a single computer known as a "host." These computer terminals are commonly known as non-programmable workstations (i.e., "dumb terminals") because they simply display information transmitted to it by the host, and lack any processing power to perform local tasks. One example of a very well-known computer terminal is the IBM 5250, which displays alphanumeric text in row and column format. In a computing environment with a host and one or more terminals, software applications run on the host, and display information is transmitted by the host to the terminals, which displays an appropriate screen to the user. The user may then enter data in response to the displayed screen, if required. Software applications that ran on these types of systems are known as "host-based" software applications. These are commonly referred to in the computer industry as "green screen" applications, taking their name from the green color of many of the dumb terminals used to interact with these applications.
Green screen applications typically display information in a text-only format of rows and columns on a terminal or computer screen. More modern advances in user interfaces have resulted in a variety of Graphical User Interfaces (GUIs) that allow a user to interact with the computer using a pointing device such as a mouse. A GUI is typically much easier for a user to use compared to a green screen interface. A GUI may provide windows, drop-down lists, context-sensitive help, etc., all at the click of a button. An example of a GUI is the OS/2 operating system developed and sold by IBM. As users become more familiar with GUI concepts, entering data into an "old fashioned" green screen application becomes more tedious and frustrating. However, converting all green screen applications to include a GUI would be a formidable and expensive undertaking.
Many green screen applications have been developed for a variety of different industries and companies at great expense. To completely re-write a green screen application to provide a GUI would take considerable time and resources. Not only would it be time-consuming and expensive to re-write a green screen application, but it also would essentially throw away much of the benefit of having stable, solid code that has been debugged and operating correctly for some period of time. A re-write would undoubtedly produce a host of new bugs that would have to be corrected. Thus, what is needed is a way to provide a GUI front-end on a green screen application to avoid rewriting the underlying logic that is tried and true.
One known solution that provides a GUI for green screen applications is known as "screen scraping." With a screen scraping approach, the underlying code of the green screen application is not affected. It still puts and gets data in data streams just as it always did. Screen scraping provides software that takes the screen information and compares the screen information against a table or other database of possible screens for the particular application. Once the screen information is correlated to a known screen, the screen scraping software knows what information needs to be displayed, and can map that information to a GUI.
While screen scraping provides a GUI for a green screen application, it does so at considerable performance cost. Essentially, one or more processes must continually run to provide the translation between green screen format and GUI format. As explained above, this translation typically requires detecting the screen to be displayed and then displaying the corresponding GUI screen. Unfortunately, the time and effort to detect the screen and provide an appropriate GUI often results in severe performance penalties. Thus the user is faced with a dilemma of whether to use the native green screen interface to achieve expected performance, or to use a new GUI screen scraping interface that significantly impacts the performance.
With the introduction of the personal computer (PC), networks for personal computers were developed that allow computers to intercommunicate. Thus, instead of providing a host-based system of the past, the personal computer made it possible to have a network of powerful workstations rather than dumb terminals. The processing power of a workstation makes it possible to share processing between computers on a network, rather than having all the processing performed by a host computer. Thus emerged a new paradigm known as client/server computing, or network computing, which allows computer workstations known as clients to interact with one or more server computers.
Migrating green screen applications that were developed for a host-based system into the client/server environment is relatively straightforward. The easiest way is for the computer workstations to emulate a dumb terminal. While this approach does not take advantage of the processing power of the client workstations, it does allow green screen applications to be implemented in a network computing environment with a minimum of effort. However, as described above, users in a network computing environment are becoming more accustomed to GUIs for their applications, and would prefer to interact with green screen applications using a GUI.
Thus, at present, the computer industry is faced with the untenable decision of whether 1) to continue to provide a green screen interface to existing applications, to the chagrin of users, 2) to provide a GUI for a green screen application using screen scraping at the cost of significant system performance, or 3) to re-write the green screen application to provide a GUI front-end. For the various reasons described above, these solutions all suffer from drawbacks, and a more cost-effective and performance-sensitive solution to providing a GUI for a green screen application is needed.